Przewodnik dotyczący wnioskowania na podstawie LLM

Interfejs LLM Inference API umożliwia uruchamianie dużych modeli językowych (LLM) całkowicie na urządzeniu. Można go używać do wykonywania wielu zadań, takich jak generowanie tekstu, pobieranie informacji w formie języka naturalnego czy streszczanie dokumentów. Zadanie zapewnia wbudowane wsparcie dla wielu dużych modeli językowych typu „tekst na tekst”, dzięki czemu możesz stosować najnowsze modele generatywnej AI na urządzeniu w swoich aplikacjach i produktach.

Wypróbuj to!arrow_forward

Zadaniem tym jest wbudowana obsługa różnych dużych modeli językowych. Modele hostowane na stronie LiteRT Community są dostępne w formacie zgodnym z MediaPipe i nie wymagają dodatkowych konwersji ani kompilacji.

Za pomocą AI Edge Torch możesz eksportować modele PyTorch do modeli LiteRT (tflite) z wieloma podpisami, które są połączone z parametrami tokenizera w pakietach zadań. Modele przekonwertowane za pomocą AI Edge Torch są zgodne z interfejsem LLM Inference API i mogą działać na procesorze CPU, dzięki czemu nadają się do aplikacji na Androida i iOS.

Rozpocznij

Aby zacząć korzystać z tego zadania, postępuj zgodnie z jednym z tych przewodników dotyczących wdrażania na platformie docelowej. Te przewodniki dotyczące poszczególnych platform zawierają podstawowe informacje o wdrożeniu tego zadania, a także przykłady kodu, które korzystają z dostępnego modelu i zalecanych opcji konfiguracji:

• Sieć:

  • Przewodnik
  • Przykładowy kod

• Android:

  • Przewodnik
  • Przykładowy kod

• iOS

  • Przewodnik
  • Przykładowy kod

Szczegóły zadania

W tej sekcji opisano możliwości, dane wejściowe, dane wyjściowe i opcje konfiguracji tego zadania.

Funkcje

Interfejs LLM Inference API zawiera te najważniejsze funkcje:

1. Generowanie tekstu na podstawie tekstu – generowanie tekstu na podstawie prompta tekstowego.
2. Wybór modelu LLM – użyj wielu modeli, aby dostosować aplikację do konkretnych zastosowań. Możesz też przeprowadzić ponowne uczenie i zastosować do modelu niestandardowe wagi.
3. Wsparcie dla LoRA – rozszerzanie i dostosowywanie możliwości LLM za pomocą modelu LoRA albo przez trenowanie na całym zbiorze danych, albo przez pobranie gotowych modeli LoRA z otwartej społeczności (niezgodne z modelami przekonwertowanymi za pomocą interfejsu AI Edge Torch Generative API).

Opcje konfiguracji

To zadanie ma te opcje konfiguracji:

Modele

Interfejs LLM Inference API obsługuje wiele dużych modeli językowych tekst-tekst, w tym wbudowane wsparcie dla kilku modeli zoptymalizowanych pod kątem działania w przeglądarkach i na urządzeniach mobilnych. Te lekkie modele można stosować do wykonywania wnioskowań bezpośrednio na urządzeniu.

Zanim zainicjujesz interfejs LLM Inference API, pobierz model i zapisz go w katalogu projektu. Możesz użyć wcześniej przekonwertowanego modelu z repozytorium HuggingFace LiteRT Community lub przekonwertować model do formatu zgodnego z MediaPipe za pomocą konwertera generatywnego AI Edge Torch.

Jeśli nie masz jeszcze modelu LLM, którego możesz używać z interfejsem LLM Inference API, zacznij od jednego z tych modeli.

Gemma-3 1B

Gemma-3 1B to najnowszy model z rodziny Gemma, czyli rodziny lekkich, najnowocześniejszych otwartych modeli opracowanych na podstawie tych samych badań i technologii, które posłużyły do stworzenia modeli Gemini. Model zawiera 1 mld parametrów i otwarte wartości wag. Wersja 1B to najlżejszy model z rodziny Gemma, dzięki czemu doskonale nadaje się do wielu zastosowań na urządzeniu.

Pobierz Gemma-3 1B

Model Gemma-3 1B z HuggingFace jest dostępny w formacie .task i gotowy do użycia z interfejsem LLM Inference API w przypadku aplikacji na Androida i w przeglądarce.

Podczas uruchamiania Gemma-3 1B z interfejsem LLM Inference API skonfiguruj te opcje:

• preferredBackend: ta opcja pozwala wybrać backend CPU lub GPU. Ta opcja jest dostępna tylko na urządzeniach z Androidem.
• supportedLoraRanks: interfejsu LLM Inference API nie można skonfigurować tak, aby obsługiwał model Gemma-3 1B w ramach adaptacji o niskim stopniu uogólniania (LoRA). Nie używaj opcji supportedLoraRanks ani loraRanks.
• maxTokens: wartość parametru maxTokens musi być zgodna z rozmiarem kontekstu wbudowanym w model. Może być też nazywany pamięcią podręczną par klucz-wartość lub długością kontekstu.
• numResponses: wartość musi zawsze wynosić 1. Ta opcja jest dostępna tylko w przeglądarce.

Podczas uruchamiania Gemma-3 1B w aplikacjach internetowych inicjalizacja może spowodować długi blok w bieżącym wątku. Jeśli to możliwe, zawsze uruchamiaj model z procesu roboczego.

Gemma-2 2B

Gemma-2 2B to wariant Gemma-2, który działa na wszystkich platformach.

Pobierz Gemma-2 2B

Model zawiera 2 mld. parametrów i otwarte współczynniki. Gemma-2 2B to model znany z najnowocześniejszych umiejętności wnioskowania w swojej klasie.

Konwersja modelu PyTorch

Modele generatywne PyTorch można przekonwertować do formatu zgodnego z MediaPipe za pomocą interfejsu AI Edge Torch Generative API. Za pomocą interfejsu API możesz konwertować modele PyTorch na modele LiteRT (TensorFlow Lite) z wieloma podpisami. Więcej informacji o mapowaniu i eksportowaniu modeli znajdziesz na stronie AI Edge Torch na GitHub.

Konwertowanie modelu PyTorch za pomocą interfejsu AI Edge Torch Generative API wymaga wykonania tych czynności:

1. Pobierz punkty kontrolne modelu PyTorch.
2. Użyj interfejsu AI Edge Torch Generative API, aby utworzyć, przekonwertować i zquantized model do formatu zgodnego z MediaPipe (.tflite).
3. Utwórz pakiet zadań (.task) z pliku tflite i tokenizera modelu.

Konwerter Torch Generative konwertuje tylko na procesor i wymaga maszyny z systemem Linux z co najmniej 64 GB pamięci RAM.

Aby utworzyć pakiet zadań, użyj skryptu pakowania, aby utworzyć pakiet zadań. Proces grupowania łączy zmapowany model z dodatkowymi metadanymi (np. Parametry analizatora potrzebne do przeprowadzenia pełnego wnioskowania.

Proces grupowania modeli wymaga pakietu MediaPipe PyPI. Skrypt konwersji jest dostępny we wszystkich pakietach MediaPipe po 0.10.14.

Zainstaluj i zaimportuj zależności za pomocą:

$ python3 -m pip install mediapipe

Aby połączyć model z biblioteką genai.bundler:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Dostosowywanie LoRa

Obsługa LoRA w LLM Inference API działa we wszystkich wariantach Gemma i modelach Phi-2 na backendzie GPU, przy czym wagi LoRA są stosowane tylko do warstw uwagi. Ta początkowa implementacja jest eksperymentalnym interfejsem API, który posłuży do przyszłych prac nad obsługą większej liczby modeli i różnych typów warstw w przyszłych aktualizacjach.

Przygotowanie modeli LoRA

Postępuj zgodnie ze wskazówkami na stronie huggingface.org, aby wytrenować dostrojony model LoRA na podstawie własnego zbioru danych z obsługiwanymi typami modeli Gemma lub Phi-2. Modele Gemma-2 2B, Gemma 2B i Phi-2 są dostępne na stronie huggingface w formacie safetensors. Ponieważ interfejs LLM Inference API obsługuje tylko LoRA na warstwach uwagi, podczas tworzenia modeluLoraConfig należy określić tylko warstwy uwagi:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Do testowania dostępne są publicznie dostępne modele LoRA, które pasują do interfejsu LLM Inference API dostępnego na HuggingFace. Na przykład: monsterapi/gemma-2b-lora-maths-orca-200k w przypadku Gemma-2B i lole25/phi-2-sft-ultrachat-lora w przypadku Phi-2.

Po wytrenowaniu modelu na przygotowanym zbiorze danych i zapisaniu go otrzymasz plik adapter_model.safetensors zawierający dostrojone wagi modelu LoRA. Plik safetensors to punkt kontrolny LoRA używany do konwertowania modelu.

W następnym kroku musisz przekonwertować wagi modelu na TensorFlow Lite Flatbuffer za pomocą pakietu MediaPipe w Pythonie. W polu ConversionConfig należy podać opcje modelu podstawowego oraz dodatkowe opcje LoRA. Ponieważ interfejs API obsługuje tylko wnioskowanie LoRA z GPU, backend musi być ustawiony na 'gpu'.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Konwerter wygeneruje 2 pliki flatbuffera TFLite: jeden dla modelu podstawowego, a drugi dla modelu LoRA.

Wnioskowanie modelu LoRA

Interfejsy API LLM Inference na potrzeby sieci Web, Androida i iOS zostały zaktualizowane, aby obsługiwać wnioskowanie modelu LoRA.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Aby uruchomić wnioskowanie LLM z LoRA, użyj tych samych metod generateResponse() lub generateResponseAsync() co w przypadku modelu podstawowego.